(* TEX STANFORD CS AUGUST 1981.
TEX WAS DESIGNED BY DONALD E. KNUTH,
WHO INITIALLY IMPLEMENTED IT IN SAIL.
THIS PASCAL VERSION OF TEX
IS DUE TO IGNACIO A. ZABALA. *)
PROGRAM SYSDEP,
INITSTRINGS, PRODUCESTRING,
APPNDSTRING, APPNDREAL,
INITSYSDEP, RELEASE,
INCHTER, INLNTER,
OUTCHERR, OUTLNERR,
SENDCH, SENDLN, SENDSTARTED, CLOSE,
PRINT, PRINTLN, PRINTINT, PRINTREAL,
PRINTFILENAME,PRINTOCTAL,
INLN, GETFIRSTLINE,
FORCEBUFFEROUT,
TRACELINE, DECLAREOFIL,
INITFILENAME, APPENDTONAME,
READFONTINFO,
DVI,INTOUT,CLOSEOUT,
SETTABLESIZES, WRITESECONDMEM,
WRITEEQTB, WRITEHYPHENTB,
WRITEPAGETB, WRITEDELIMTB, WRITEFMEM,
GETTABLESIZES,INITSECONDMEM,INITEQTB,INITHYPHENTB,
INITPAGETB,INITDELIMTB,INITFMEM;
CONST TERDEVICE='TTY   ';
TYPE ONEOFTWO= 1..2;
ONEOFFOUR= 1..4;
ONEOFFIVE= 1..5;
ONEOFSIX= 1..6;
HALVES2= PACKED RECORD
LHWORD: 0..65535;
CASE ONEOFTWO OF
1:(RHWORD: 0..65535);
2:(BYTE2: 0..255;
BYTE3: 0..255)
END;
BYTES4= PACKED RECORD
BYTE0: 0..255;
BYTE1: 0..255;
CASE ONEOFTWO OF
1:(RHWORD: 0..65535);
2:(BYTE2: 0..255;
BYTE3: 0..255)
END;
MEMORYWORD= PACKED RECORD CASE
ONEOFFOUR OF
1:(PTS: REAL);
2:(INT: INTEGER);
3:(TWOHALVES: HALVES2);
4:(FOURBYTES: BYTES4)
END;
ASCIICODE= 0..127;
ASCIISTRING= ARRAY[0..63] OF
ASCIICODE;
PACKEDASCIISTRING= PACKED ARRAY
[0..63] OF ASCIICODE;
CHAR9= PACKED ARRAY[1..9] OF
CHAR;
CHAR6= PACKED ARRAY[1..6] OF
CHAR;
BUFFIR= ARRAY[1..200] OF ASCIICODE;
FNTINFOARRAY= ARRAY[0..63,0..127]
OF BYTES4;
FMEMARRAY= ARRAY[0..6399] OF
MEMORYWORD;
FBASEARRAY= ARRAY[0..63] OF
INTEGER;
FPFIARRAY= ARRAY[0..63,1..5]
OF BYTES4;
SIZESARRAY= ARRAY[0..11] OF
INTEGER;
MEMARRAY= ARRAY[0..49152] OF
MEMORYWORD;
EQTBARRAY= ARRAY[0..1428] OF
MEMORYWORD;
HASHARRAY= ARRAY[23..1009] OF
HALVES2;
HHEADARRAY= ARRAY[0..88] OF
INTEGER;
PAGEMEMARRAY= ARRAY[0..7] OF
REAL;
DELIMARRAY= ARRAY[0..127] OF
BYTES4;
EXCEPTION=PACKED ARRAY[1..12]
OF 0..31;

HYPHENBITS=SET OF 1..16;
PACKEDHYPHENBITS=PACKED SET OF
1..16;
PACKEDALPHAS=PACKED SET OF 0..26
;

PACKEDCONSONANTPAIRENTRY=PACKED
RECORD
HCHAR:0..7;
WEAK:0..7;
ALPHASET:PACKEDALPHAS
END;

OPCODE=0..15;
TRUTHX=0..255;
HOPERAND=0..255;
SUFFIXTP=PACKED RECORD
CODE: OPCODE;
CASE ONEOFTWO OF
1:(TRUEX:TRUTHX;
FALSEX:TRUTHX;
OPRAND:HOPERAND);
2:(ALPHASET:PACKEDALPHAS)
END;
PREFIXTP=SUFFIXTP;
TABLEREADOUTTYPE= RECORD CASE
ONEOFSIX OF
1:(EXCPTABLEVARIANT:EXCEPTION);
2:(EXCEPHYPHVARIANT:PACKEDHYPHENBITS);
3:(SUFFIXVARIANT:SUFFIXTP);
4:(PREFIXVARIANT:PREFIXTP);
5:(BTABLEVARIANT:PACKEDCONSONANTPAIRENTRY);
6:(READOUTVARIANT:ARRAY[1..3]
OF INTEGER)
END;
EXCPARRAY= ARRAY[0..372] OF
EXCEPTION;
EXCPHYARRAY= ARRAY[1..372] OF
PACKEDHYPHENBITS;
SUFFIXARRAY= ARRAY[0..115] OF
SUFFIXTP;
PREFIXARRAY= ARRAY[0..108] OF
PREFIXTP;
BARRAY= ARRAY[2..31] OF PACKEDCONSONANTPAIRENTRY;
VAR TEROUT: PACKED FILE OF ASCII;
TERIN: PACKED FILE OF ASCII;
ERRFIL: PACKED FILE OF ASCII;
FONTFIL: FILE OF MEMORYWORD;
OUTFIL: FILE OF INTEGER;
TBLFIL: FILE OF INTEGER;
FILENAME: ARRAY[0..80] OF PACKEDASCIISTRING;
FILPTR: INTEGER;
FOURBYTEMASK: INTEGER;
STRNG: ARRAY[-1..999] OF INTEGER;
STRNGPOOL: PACKED ARRAY[-1..6000]
OF ASCIICODE;
STRNGINX: INTEGER;
POOLINX: INTEGER;
ICHAN1: PACKED FILE OF ASCII;
ICHAN2: PACKED FILE OF ASCII;
ICHAN3: PACKED FILE OF ASCII;
ICHAN4: PACKED FILE OF ASCII;
ICHAN5: PACKED FILE OF ASCII;
ICHAN6: PACKED FILE OF ASCII;
OCHAN0: PACKED FILE OF ASCII;
OCHAN1: PACKED FILE OF ASCII;
OCHAN2: PACKED FILE OF ASCII;
OCHAN3: PACKED FILE OF ASCII;
OCHAN4: PACKED FILE OF ASCII;
OCHAN5: PACKED FILE OF ASCII;
OCHAN6: PACKED FILE OF ASCII;
OCHAN7: PACKED FILE OF ASCII;
OCHAN8: PACKED FILE OF ASCII;
OCHAN9: PACKED FILE OF ASCII;
FILETYPE:(FONTFILE,SENDFILE,INPUTFILE);
FNSTRING: ASCIISTRING;
FNL: INTEGER;
FIL: INTEGER;
FNAME: CHAR9;
FDIR: INTEGER;
FPRGMR: INTEGER;
FJ: INTEGER;
FNSTATE:(NAMEPART,EXTENSION,PROJECT,PROGRAMMER,SKIP);
DVIWORD: MEMORYWORD;
BYTENUM: INTEGER;
FUNCTION INTMAX(X,Y: INTEGER):
INTEGER;
BEGIN
IF X>Y THEN INTMAX:=X
ELSE INTMAX:=Y;
END;
FUNCTION INTMIN(M,N: INTEGER):
INTEGER;
BEGIN
IF M>N THEN INTMIN:=N
ELSE INTMIN:=M;
END;
PROCEDURE INITSTRINGS;
LABEL 10, 0;
VAR C: ASCIICODE;
CHARTABLE: BOOLEAN;
BEGIN
STRNG[-1]:=-1;
STRNGPOOL[-1]:=0;
STRNG[0]:=0;
STRNGINX:=1;
POOLINX:=0;
RESET(ICHAN1,'ASCII TBL',0,244570637163B+400000000000B);
CHARTABLE:=TRUE;
10:
WHILE NOT EOF(ICHAN1) DO
BEGIN C:=ORD(ICHAN1↑);
WHILE C=0 DO BEGIN GET(ICHAN1);
C:=ORD(ICHAN1↑) END;
WHILE(C=13) OR(C=12) DO
BEGIN
STRNGPOOL[POOLINX]:=0;
POOLINX:=POOLINX+1;
STRNG[STRNGINX]:=POOLINX;
STRNGINX:=STRNGINX+1;
REPEAT GET(ICHAN1);
IF EOF(ICHAN1) THEN GOTO 0;
C:=ORD(ICHAN1↑)
UNTIL(C<>10) AND(C<>0);
END;
STRNGPOOL[POOLINX]:=C;
POOLINX:=POOLINX+1;

GET(ICHAN1)
END;
0:
IF CHARTABLE THEN
BEGIN CHARTABLE:=FALSE;
RESET(ICHAN1,'STRINITBL',0,244570637163B+400000000000B);
GOTO 10
END;
RESET(ICHAN1);
END;
PROCEDURE PRODUCESTRING(C: INTEGER;
VAR NAMESTRING: ASCIISTRING);
VAR I,J: INTEGER;
BEGIN
IF C<=(-(0)-2) THEN UNPACK(FILENAME[(-(C)-2)
],NAMESTRING,0)
ELSE BEGIN
I:=-1;
J:=STRNG[C]-1;
REPEAT J:=J+1;
I:=I+1;

NAMESTRING[I]:=STRNGPOOL[J]
UNTIL STRNGPOOL[J]=0
END
END;
FUNCTION APPNDSTRING(D,S: INTEGER):
INTEGER;
VAR I,J: INTEGER;
SSTRING,DSTRING: ASCIISTRING;
BEGIN
PRODUCESTRING(S,SSTRING);
I:=-1;
IF D<=(-(0)-2) THEN BEGIN
UNPACK(FILENAME[(-(D)-2)],DSTRING,0);
J:=0;
WHILE DSTRING[J]<>0 DO J:=J+1
;
REPEAT I:=I+1;
DSTRING[J]:=SSTRING[I];
J:=J+1;

UNTIL SSTRING[I]=0;
PACK(DSTRING,0,FILENAME[(-(D)-2)]);
APPNDSTRING:=D;
END
ELSE BEGIN REPEAT I:=I+1;
STRNGPOOL[POOLINX]:=SSTRING[I];
POOLINX:=POOLINX+1;

UNTIL SSTRING[I]=0;
STRNG[STRNGINX]:=POOLINX;
STRNGINX:=STRNGINX+1;

APPNDSTRING:=STRNGINX-2;
END
END;
FUNCTION APPNDREAL(D:INTEGER;
S:REAL): INTEGER;
VAR I,J: INTEGER;
SSTRING,DSTRING: ASCIISTRING;
BEGIN
I:=TRUNC((S+0.05)*10);
SSTRING[5]:=0;
SSTRING[4]:=(I MOD 10)+48;
I:=I DIV 10;
SSTRING[3]:=46;
FOR J:=2 DOWNTO 0 DO
IF I>0 THEN BEGIN SSTRING[J]:=(I
MOD 10)+48;
I:=I DIV 10;
END
ELSE SSTRING[J]:=32;
I:=-1;
IF D<=(-(0)-2) THEN BEGIN
UNPACK(FILENAME[(-(D)-2)],DSTRING,0);
J:=0;
WHILE DSTRING[J]<>0 DO J:=J+1
;
REPEAT I:=I+1;
DSTRING[J]:=SSTRING[I];
J:=J+1;

UNTIL SSTRING[I]=0;
PACK(DSTRING,0,FILENAME[(-(D)-2)]);
APPNDREAL:=D;
END
ELSE BEGIN REPEAT I:=I+1;
STRNGPOOL[POOLINX]:=SSTRING[I];
POOLINX:=POOLINX+1;

UNTIL SSTRING[I]=0;
STRNG[STRNGINX]:=POOLINX;
STRNGINX:=STRNGINX+1;

APPNDREAL:=STRNGINX-2;
END
END;
PROCEDURE INITSYSDEP(VAR FOURBYTESIZE:
INTEGER);
VAR I: INTEGER;
BEGIN
IF MAXINT>17777777777B THEN FOURBYTESIZE:=40000000000B

ELSE FOURBYTESIZE:=0;
FOURBYTEMASK:=FOURBYTESIZE;
REWRITE(TEROUT,'FOOBARTTY',0,0,TERDEVICE);
REWRITE(ERRFIL,'ERRORSTEM');
FOR I:=0 TO 64 DO FILENAME[I,0]:=0;
FILPTR:=10+65;
BYTENUM:=1;
DVIWORD.INT:=0;
END;
PROCEDURE RSETFILE(ID: INTEGER;
FNAME: CHAR9;
FDIRECTORY: INTEGER;
FDEVICE: CHAR6);
BEGIN
CASE ID OF
1: RESET(ICHAN1,FNAME,0,FDIRECTORY,FDEVICE);
2: RESET(ICHAN2,FNAME,0,FDIRECTORY,FDEVICE);
3: RESET(ICHAN3,FNAME,0,FDIRECTORY,FDEVICE);
4: RESET(ICHAN4,FNAME,0,FDIRECTORY,FDEVICE);
5: RESET(ICHAN5,FNAME,0,FDIRECTORY,FDEVICE);
6: RESET(ICHAN6,FNAME,0,FDIRECTORY,FDEVICE)

END
END;
FUNCTION EOFCHAN(ID: INTEGER):
BOOLEAN;
BEGIN
CASE ID OF
1: EOFCHAN:= EOF(ICHAN1);
2: EOFCHAN:= EOF(ICHAN2);
3: EOFCHAN:= EOF(ICHAN3);
4: EOFCHAN:= EOF(ICHAN4);
5: EOFCHAN:= EOF(ICHAN5);
6: EOFCHAN:= EOF(ICHAN6)
END
END;
PROCEDURE GETCHAN(ID: INTEGER);
BEGIN
CASE ID OF
1: GET(ICHAN1);
2: GET(ICHAN2);
3: GET(ICHAN3);
4: GET(ICHAN4);
5: GET(ICHAN5);
6: GET(ICHAN6)
END
END;
FUNCTION CHANPTR(ID: INTEGER):
ASCIICODE;
BEGIN
CASE ID OF
1: CHANPTR:= ORD(ICHAN1↑);
2: CHANPTR:= ORD(ICHAN2↑);
3: CHANPTR:= ORD(ICHAN3↑);
4: CHANPTR:= ORD(ICHAN4↑);
5: CHANPTR:= ORD(ICHAN5↑);
6: CHANPTR:= ORD(ICHAN6↑)
END
END;
PROCEDURE RWRITEFILE(ID: INTEGER;
FNAME: CHAR9;
FDIRECTORY: INTEGER;
FDEVICE: CHAR6);
BEGIN
CASE ID OF
0: REWRITE(OCHAN0,FNAME,0,FDIRECTORY,FDEVICE);
1: REWRITE(OCHAN1,FNAME,0,FDIRECTORY,FDEVICE);
2: REWRITE(OCHAN2,FNAME,0,FDIRECTORY,FDEVICE);
3: REWRITE(OCHAN3,FNAME,0,FDIRECTORY,FDEVICE);
4: REWRITE(OCHAN4,FNAME,0,FDIRECTORY,FDEVICE);
5: REWRITE(OCHAN5,FNAME,0,FDIRECTORY,FDEVICE);
6: REWRITE(OCHAN6,FNAME,0,FDIRECTORY,FDEVICE);
7: REWRITE(OCHAN7,FNAME,0,FDIRECTORY,FDEVICE);
8: REWRITE(OCHAN8,FNAME,0,FDIRECTORY,FDEVICE);
9: REWRITE(OCHAN9,FNAME,0,FDIRECTORY,FDEVICE);
END;
END;
FUNCTION SENDSTARTED(STREAM: INTEGER):
BOOLEAN;
BEGIN
CASE STREAM OF
0: SENDSTARTED:=EOF(OCHAN0);
1: SENDSTARTED:=EOF(OCHAN1);
2: SENDSTARTED:=EOF(OCHAN2);
3: SENDSTARTED:=EOF(OCHAN3);
4: SENDSTARTED:=EOF(OCHAN4);
5: SENDSTARTED:=EOF(OCHAN5);
6: SENDSTARTED:=EOF(OCHAN6);
7: SENDSTARTED:=EOF(OCHAN7);
8: SENDSTARTED:=EOF(OCHAN8);
9: SENDSTARTED:=EOF(OCHAN9)
END;
END;
PROCEDURE CLOSE(STREAM: INTEGER);
BEGIN
CASE STREAM OF
0: RESET(OCHAN0);
1: RESET(OCHAN1);
2: RESET(OCHAN2);
3: RESET(OCHAN3);
4: RESET(OCHAN4);
5: RESET(OCHAN5);
6: RESET(OCHAN6);
7: RESET(OCHAN7);
8: RESET(OCHAN8);
9: RESET(OCHAN9)
END
END;
FUNCTION INCHTER: ASCIICODE;
BEGIN
BREAK(TEROUT);
RESET(TERIN,'FOOBARTTY',0,0,TERDEVICE);
INCHTER:= ORD(TERIN↑);
WHILE TERIN↑<>CHR(13) DO GET(TERIN)
END;
PROCEDURE INLNTER(VAR BUFFER:
BUFFIR;
VAR BUFPTR: INTEGER;
VAR BRCHAR: ASCIICODE);
LABEL 0;
VAR C: ASCIICODE;
BEGIN BREAK(TEROUT);
RESET(TERIN,'FOOBARTTY',0,0,TERDEVICE);
BUFPTR:=1;
REPEAT
C:=ORD(TERIN↑);
BUFFER[BUFPTR]:=C;
IF C=13 THEN
BEGIN
BRCHAR:=C;
GOTO 0;
END;
GET(TERIN);
BUFPTR:=BUFPTR+1;

UNTIL BUFPTR=200;
BUFFER[200]:=0;
BRCHAR:=0;
0:
END;
PROCEDURE OUTCHTER(C: ASCIICODE);
BEGIN TEROUT↑:=CHR(C);
PUT(TEROUT)
END;
PROCEDURE OUTLNERR;
BEGIN
ERRFIL↑:=CHR(13);
PUT(ERRFIL);
ERRFIL↑:=CHR(10);
PUT(ERRFIL)
END;
PROCEDURE OUTCHERR(C: ASCIICODE);
BEGIN ERRFIL↑:=CHR(C);
PUT(ERRFIL)
END;
PROCEDURE SENDCH(STREAM: INTEGER;
C: ASCIICODE);
BEGIN
CASE STREAM OF
0: BEGIN OCHAN0↑:=CHR(C);
PUT(OCHAN0) END;
1: BEGIN OCHAN1↑:=CHR(C);
PUT(OCHAN1) END;
2: BEGIN OCHAN2↑:=CHR(C);
PUT(OCHAN2) END;
3: BEGIN OCHAN3↑:=CHR(C);
PUT(OCHAN3) END;
4: BEGIN OCHAN4↑:=CHR(C);
PUT(OCHAN4) END;
5: BEGIN OCHAN5↑:=CHR(C);
PUT(OCHAN5) END;
6: BEGIN OCHAN6↑:=CHR(C);
PUT(OCHAN6) END;
7: BEGIN OCHAN7↑:=CHR(C);
PUT(OCHAN7) END;
8: BEGIN OCHAN8↑:=CHR(C);
PUT(OCHAN8) END;
9: BEGIN OCHAN9↑:=CHR(C);
PUT(OCHAN9) END
END;
END;
PROCEDURE SENDLN(STREAM: INTEGER);
BEGIN
SENDCH(STREAM,13);
SENDCH(STREAM,10);
END;
PROCEDURE PRINT(MES: INTEGER);
VAR I: INTEGER;
C: ASCIICODE;
BEGIN
I:=STRNG[MES];
C:=STRNGPOOL[I];
WHILE C<>0 DO
BEGIN
TEROUT↑:=CHR(C);
ERRFIL↑:=CHR(C);
PUT(TEROUT);
PUT(ERRFIL);
I:=I+1;
C:=STRNGPOOL[I]
END;
END;
PROCEDURE PRINTLN(MES: INTEGER);
BEGIN
TEROUT↑:=CHR(13);
ERRFIL↑:= TEROUT↑;
PUT(TEROUT);
PUT(ERRFIL);
TEROUT↑:=CHR(10);
ERRFIL↑:= TEROUT↑;
PUT(TEROUT);
PUT(ERRFIL);
PRINT(MES)
END;
PROCEDURE PRINTINT(N: INTEGER);
VAR M: INTEGER;
K: INTEGER;
S: ARRAY[1..11] OF ASCIICODE;
BEGIN
IF N=0 THEN PRINT(48)
ELSE BEGIN
K:=12;
IF N<0 THEN BEGIN PRINT(45);
N:=-N END;
WHILE N<>0 DO
BEGIN
M:=N MOD 10;
K:=K-1;

CASE M OF
0: S[K]:=48;
1: S[K]:=49;
2: S[K]:=50;
3: S[K]:=51;
4: S[K]:=52;
5: S[K]:=53;
6: S[K]:=54;
7: S[K]:=55;
8: S[K]:=56;
9: S[K]:=57
END;
N:= N DIV 10;
END;
FOR K:=K TO 11 DO PRINT(S[K]);
END
END;
PROCEDURE PRINTOCTAL(N: INTEGER);
VAR I: INTEGER;
K: INTEGER;
S: ARRAY[0..11] OF ASCIICODE;
MSB: BOOLEAN;
BEGIN
MSB:=FALSE;
IF N<0 THEN BEGIN N:=N-400000000000B;
MSB:=TRUE END;
FOR K:=11 DOWNTO 0 DO
BEGIN
I:=N MOD 8;
IF(K=0) AND MSB THEN I:=I+4;
CASE I OF
0: S[K]:=48;
1: S[K]:=49;
2: S[K]:=50;
3: S[K]:=51;
4: S[K]:=52;
5: S[K]:=53;
6: S[K]:=54;
7: S[K]:=55
END;
N:= N DIV 8;
END;
PRINT(39);
K:=0;
WHILE(K<11) AND(S[K]=48) DO
K:=K+1;

FOR K:=K TO 11 DO PRINT(S[K])

END;
PROCEDURE PRINTREAL(X: REAL);
VAR N: INTEGER;
BEGIN
IF X<0 THEN BEGIN PRINT(45);
X:=-X END;
IF X>1000000001 THEN PRINT(128)
ELSE IF X<0.0001 THEN PRINT(129)
ELSE BEGIN
N:=TRUNC(X+0.00005);
PRINTINT(N);
IF X<(N+0.00005) THEN PRINT(130)

ELSE BEGIN PRINT(46);
N:=ROUND((X-N)*10000);
PRINT(48+(N DIV 1000));
N:= N MOD 1000;
PRINT(48+(N DIV 100));
N:= N MOD 100;
PRINT(48+(N DIV 10));
N:= N MOD 10;
PRINT(48+N);
END
END;
END;
PROCEDURE FORCEBUFFEROUT;
BEGIN
BREAK(TEROUT);
END;
PROCEDURE PRINTFILENAME(FYL: INTEGER);
VAR S: ASCIISTRING;
I: INTEGER;
BEGIN
UNPACK(FILENAME[FYL],S,0);
I:=0;
WHILE S[I]<>0 DO
BEGIN PRINT(S[I]);
I:=I+1
END;
FORCEBUFFEROUT;
END;
PROCEDURE INLN(FYL: INTEGER;
VAR BUFFER: BUFFIR;
VAR BUFPTR: INTEGER;
VAR BRCHAR: ASCIICODE;
VAR EOFF: BOOLEAN);
LABEL 0;
VAR C: ASCIICODE;
BEGIN
C:=CHANPTR(FYL);
BUFPTR:=1;
EOFF:=FALSE;
IF C=10 THEN BEGIN GETCHAN(FYL);
C:=CHANPTR(FYL) END;
REPEAT
WHILE C=0 DO BEGIN GETCHAN(FYL);
C:=CHANPTR(FYL) END;
IF EOFCHAN(FYL) THEN BEGIN EOFF:=TRUE;
IF BUFPTR<>1 THEN BEGIN BUFFER[BUFPTR]:=13;
BRCHAR:=13
END;
GOTO 0
END;
BUFFER[BUFPTR]:=C;
GETCHAN(FYL);
IF(C=13) OR(C=12) THEN BEGIN
BRCHAR:=C;
GOTO 0
END
ELSE BUFPTR:=BUFPTR+1;

C:=CHANPTR(FYL)
UNTIL BUFPTR=150;
BRCHAR:=0;
0:
END;
FUNCTION GETFIRSTLINE(FYL: INTEGER;
VAR BUFFER: BUFFIR;
VAR BUFPTR: INTEGER;
VAR BRCHAR: ASCIICODE;
VAR EOFF: BOOLEAN;
VAR PAGE: INTEGER): BOOLEAN;
LABEL 0;
BEGIN
GETFIRSTLINE:= TRUE;
INLN(FYL,BUFFER,BUFPTR,BRCHAR,EOFF);
IF EOFF THEN BEGIN GETFIRSTLINE:=FALSE;
GOTO 0 END;

PRINT(32);
PRINT(49);
IF(BUFFER[1]=67)
AND(BUFFER[2]=79)
AND(BUFFER[3]=77)
AND(BUFFER[4]=77)
AND(BUFFER[5]=69)
AND(BUFFER[6]=78)
AND(BUFFER[7]=84)
AND(BUFFER[8]=32)
AND(BUFFER[9]=22)
THEN BEGIN
WHILE(BRCHAR<>12) AND NOT EOFF
DO INLN(FYL,BUFFER,BUFPTR,BRCHAR,EOFF);
IF EOFF THEN BEGIN GETFIRSTLINE:=FALSE;
GOTO 0 END;

INLN(FYL,BUFFER,BUFPTR,BRCHAR,EOFF);
IF EOFF THEN BEGIN GETFIRSTLINE:=FALSE;
GOTO 0 END;

PRINT(32);
PRINT(50);
PAGE:=2;
END
ELSE PAGE:=1;
WHILE BRCHAR=12 DO
BEGIN
INLN(FYL,BUFFER,BUFPTR,BRCHAR,EOFF);
IF EOFF THEN BEGIN GETFIRSTLINE:=FALSE;
GOTO 0 END;

PAGE:=PAGE+1;

PRINT(32);
PRINTINT(PAGE)
END;

0:
END;
PROCEDURE RELEASE(FYL: INTEGER);
BEGIN
CASE FYL OF
1: RESET(ICHAN1);
2: RESET(ICHAN2);
3: RESET(ICHAN3);
4: RESET(ICHAN4);
5: RESET(ICHAN5);
6: RESET(ICHAN6)
END;
FILPTR:=FILPTR-1
END;
PROCEDURE TRACELINE(VAR BUFFER:
BUFFIR;
VAR BUFPTR: INTEGER);
VAR
FIRST,LAST: INTEGER;
BRCHAR, OLDBRCHAR: ASCIICODE;
J: INTEGER;
BEGIN
TEROUT↑:=CHR(13);
ERRFIL↑:= TEROUT↑;
PUT(TEROUT);
PUT(ERRFIL);
TEROUT↑:=CHR(10);
ERRFIL↑:= TEROUT↑;
PUT(TEROUT);
PUT(ERRFIL);
IF BUFFER[1]=10 THEN FIRST:=2
ELSE FIRST:=1;
IF BUFFER[BUFPTR]=0 THEN LAST:=BUFPTR
ELSE LAST:=BUFPTR-1;
IF LAST<=FIRST THEN OUTCHTER(32);
FOR J:=FIRST TO LAST DO OUTCHTER(BUFFER[J])
;

IF INCHTER<>13 THEN BEGIN
OLDBRCHAR:=BUFFER[BUFPTR];
REPEAT GET(TERIN) UNTIL ORD(TERIN↑)=10;
INLNTER(BUFFER,BUFPTR,BRCHAR);
BUFFER[BUFPTR]:=OLDBRCHAR;
FIRST:=1;
LAST:=BUFPTR;
END;

FOR J:=FIRST TO LAST DO OUTCHERR(BUFFER[J])
;

END;
PROCEDURE DECLAREOFIL(FYL: INTEGER);
LABEL 0;

VAR OUTFYLNAM: CHAR9;
OUTDEV: CHAR6;
NODEV: BOOLEAN;
S: ASCIISTRING;
C: ASCIICODE;
I,J: INTEGER;
BEGIN
OUTFYLNAM:='TEXOUTDVI';
NODEV:=TRUE;
IF FYL<>-3 THEN BEGIN
UNPACK(FILENAME[FYL],S,0);
J:=0;
I:=1;
REPEAT
C:=S[J];
IF C=58 THEN
BEGIN FOR I:=1 TO I-1 DO OUTDEV[I]:=OUTFYLNAM[I];
NODEV:=FALSE;
I:=1
END
ELSE IF(C=46) OR(C=0) THEN GOTO
0
ELSE IF I<=6 THEN
BEGIN
BEGIN
IF(C>=97) AND(C<=122)
THEN C:=C-32
END;
OUTFYLNAM[I]:=CHR(C);
I:=I+1
END;
J:=J+1
UNTIL J>=64;
0:
FOR I:=I TO 6 DO OUTFYLNAM[I]:=' '

END;
IF NODEV THEN REWRITE(OUTFIL,OUTFYLNAM)
ELSE REWRITE(OUTFIL,OUTFYLNAM,0,0,OUTDEV)

END;
FUNCTION INITFILENAME(FNUM: INTEGER):
INTEGER;
LABEL 50;
BEGIN
IF FNUM=-2 THEN
BEGIN
FIL:=FILPTR-(74);
IF FIL>6 THEN BEGIN FIL:=-1;
GOTO 50
END;
FILETYPE:=INPUTFILE;
FNAME:='      TEX';
END
ELSE IF FNUM>64 THEN BEGIN
FIL:=FNUM-(65);
FILETYPE:=SENDFILE;
FNAME:='      TEX';
END
ELSE BEGIN
FIL:=FNUM;
FILETYPE:=FONTFILE;
FNAME:='      TFM';
END;
FNL:=0;
FDIR:=0;
FPRGMR:=0;
FNSTATE:=NAMEPART;
FOR FJ:=0 TO 63 DO FNSTRING[FJ]:=0;
FJ:=1;
50:
INITFILENAME:=FIL;
END;
FUNCTION APPENDTONAME(CMMD, CH:
INTEGER): INTEGER;
LABEL 50;
VAR PROBLEMS: BOOLEAN;
JJ: INTEGER;
BEGIN
IF CMMD>13 THEN
BEGIN PRINTLN(131);
APPENDTONAME:=2
END
ELSE IF CMMD=10 THEN BEGIN
IF FNSTATE=PROGRAMMER THEN BEGIN
FDIR:=FDIR+FPRGMR;
FNSTRING[FNL]:=93;
FNL:=FNL+1;

END
ELSE IF(FNSTATE=NAMEPART) AND
(FILETYPE<>FONTFILE) THEN BEGIN

FNSTRING[FNL]:=46;
FNL:=FNL+1;

FNSTRING[FNL]:=84;
FNL:=FNL+1;

FNSTRING[FNL]:=69;
FNL:=FNL+1;

FNSTRING[FNL]:=88;
FNL:=FNL+1;

FJ:=FNL;
END;
CASE FILETYPE OF
INPUTFILE: BEGIN
RSETFILE(FIL,FNAME,FDIR,'DSK   ');
IF EOFCHAN(FIL) THEN
IF FDIR=0 THEN
BEGIN
RSETFILE(FIL,FNAME,244570637163B+400000000000B
,'DSK   ');
IF EOFCHAN(FIL) THEN APPENDTONAME:=1

ELSE BEGIN
FNSTRING[FJ]:=91;
FJ:=FJ+1;

FNSTRING[FJ]:=84;
FJ:=FJ+1;

FNSTRING[FJ]:=69;
FJ:=FJ+1;

FNSTRING[FJ]:=88;
FJ:=FJ+1;

FNSTRING[FJ]:=44;
FJ:=FJ+1;

FNSTRING[FJ]:=83;
FJ:=FJ+1;

FNSTRING[FJ]:=89;
FJ:=FJ+1;

FNSTRING[FJ]:=83;
FJ:=FJ+1;

FNSTRING[FJ]:=93;
FJ:=FJ+1;

FILPTR:=FILPTR+1;

APPENDTONAME:=0
END
END
ELSE APPENDTONAME:=1
ELSE BEGIN FILPTR:=FILPTR+1;
APPENDTONAME:=0
END;
PACK(FNSTRING,0,FILENAME[74+FIL]);
END;
FONTFILE: BEGIN
IF FDIR=244570637163B+400000000000B

THEN FNSTRING[FNL-9]:=0
ELSE
IF FDIR=0 THEN FDIR:=244570637163B+400000000000B
;

PACK(FNSTRING,0,FILENAME[FIL]);
IF FIL=64 THEN APPENDTONAME:=0
ELSE BEGIN
RESET(FONTFIL,FNAME,0,FDIR);
IF EOF(FONTFIL) THEN APPENDTONAME:=1

ELSE APPENDTONAME:=0
END
END;
SENDFILE: BEGIN
IF SENDSTARTED(FIL) THEN CLOSE(FIL);
RWRITEFILE(FIL,FNAME,FDIR,'DSK   ');
PACK(FNSTRING,0,FILENAME[65+FIL]);
APPENDTONAME:=0;
END
END
END
ELSE BEGIN
BEGIN
IF(CH>=97) AND(CH<=122)
THEN CH:=CH-32
END;
CASE FNSTATE OF
NAMEPART: IF CH=46 THEN
BEGIN
IF FILETYPE<>FONTFILE THEN BEGIN

FJ:=7;
FNAME[7]:=' ';
FNAME[8]:=' ';
FNAME[9]:=' ';
END;
FNSTATE:=EXTENSION
END
ELSE IF CH=91 THEN
BEGIN
IF FILETYPE<>FONTFILE THEN
BEGIN
FNSTRING[FNL]:=46;
FNL:=FNL+1;

FNSTRING[FNL]:=84;
FNL:=FNL+1;

FNSTRING[FNL]:=69;
FNL:=FNL+1;

FNSTRING[FNL]:=88;
FNL:=FNL+1;

END;
FNSTATE:=PROJECT
END
ELSE IF FJ<=6 THEN
BEGIN
FNAME[FJ]:=CHR(CH);
FJ:=FJ+1
END;
EXTENSION:
BEGIN
IF FILETYPE=FONTFILE THEN FNL:=FNL-1
;
IF CH=91 THEN FNSTATE:=PROJECT

ELSE IF FILETYPE=FONTFILE THEN
GOTO 50
ELSE IF(FJ<=9) THEN
BEGIN
FNAME[FJ]:=CHR(CH);
FJ:=FJ+1
END;
END;
PROJECT: IF CH=44 THEN
BEGIN
IF FDIR>=400000B THEN
FDIR:=(FDIR-400000B)*1000000B+400000000000B

ELSE FDIR:=FDIR*1000000B;
FNSTATE:=PROGRAMMER
END
ELSE FDIR:=FDIR*100B+(CH-40B);
PROGRAMMER: IF CH=93 THEN
BEGIN FDIR:=FDIR+FPRGMR;
FNSTATE:=SKIP
END
ELSE FPRGMR:=FPRGMR*100B+(CH-40B);
SKIP: GOTO 50
END;
IF FNL<=64 THEN BEGIN BEGIN IF
(CH>=65) AND(CH<=90) THEN CH:=CH+32
END;
FNSTRING[FNL]:=CH;
FNL:=FNL+1
END;
50:
APPENDTONAME:=3
END
END;
FUNCTION READFONTINFO(FYL: INTEGER;
VAR FONTINFO: FNTINFOARRAY;
VAR FMEM: FMEMARRAY;
VAR WDBASE,HTBASE,DPBASE,ICBASE,LGBASE,KRBASE,EXTBASE,PARBASE:
FBASEARRAY;
VAR FCKSUM,FPFB,FMAG: FBASEARRAY;
VAR FPFI: FPFIARRAY;
VAR FMEMPTR: INTEGER;
PSIZE: REAL;
ATCLAUSE: BOOLEAN): INTEGER;
VAR
FL,LH,EC,BC,NW,NH,ND,NI,NL,NK,NE,NP:
INTEGER;
FBT: MEMORYWORD;
I,M,P: INTEGER;
DSIZE,METRICSCALE: REAL;
FC,LC: INTEGER;
FBC,LEC: INTEGER;
BEGIN
FL:=FONTFIL↑.TWOHALVES.LHWORD;
LH:=FONTFIL↑.TWOHALVES.RHWORD;
GET(FONTFIL);
BC:=FONTFIL↑.TWOHALVES.LHWORD;
EC:=FONTFIL↑.TWOHALVES.RHWORD;
GET(FONTFIL);
NW:=FONTFIL↑.TWOHALVES.LHWORD;
NH:=FONTFIL↑.TWOHALVES.RHWORD;
GET(FONTFIL);
ND:=FONTFIL↑.TWOHALVES.LHWORD;
NI:=FONTFIL↑.TWOHALVES.RHWORD;
GET(FONTFIL);
NL:=FONTFIL↑.TWOHALVES.LHWORD;
NK:=FONTFIL↑.TWOHALVES.RHWORD;
GET(FONTFIL);
NE:=FONTFIL↑.TWOHALVES.LHWORD;
NP:=FONTFIL↑.TWOHALVES.RHWORD;
M:=(FL-LH-EC+BC-7);;

IF(FMEMPTR+M>=6400) THEN READFONTINFO:=1
ELSE BEGIN
GET(FONTFIL);
FCKSUM[FYL]:=FONTFIL↑.INT DIV
20B;
GET(FONTFIL);
DSIZE:=(FONTFIL↑.INT DIV 20B)/4000000B;
IF ATCLAUSE THEN METRICSCALE:=PSIZE
ELSE METRICSCALE:=DSIZE;
FMAG[FYL]:=TRUNC(1000.0*METRICSCALE/DSIZE);
FOR I:=1 TO 10 DO GET(FONTFIL);
FOR I:=1 TO 5 DO BEGIN GET(FONTFIL);
FPFI[FYL,I]:=FONTFIL↑.FOURBYTES;
END;
GET(FONTFIL);
FBT:=FONTFIL↑;
FPFB[FYL]:=FBT.FOURBYTES.BYTE3;
FOR I:=1 TO(LH-18) DO GET(FONTFIL);
;

FBT.INT:=0;
FC:=0;
LC:=127;
FOR I:=BC TO INTMIN(EC,FC-1) DO
GET(FONTFIL);
FOR I:=FC TO INTMIN(LC,BC-1) DO
FONTINFO[FYL,I-FC]:=FBT.FOURBYTES;
FBC:=INTMAX(BC,FC);
LEC:=INTMIN(EC,LC);
FOR I:=FBC-FC TO(FBC-FC+INTMAX(LEC-FBC+1,0)-1)
DO
BEGIN GET(FONTFIL);
FONTINFO[FYL,I]:=FONTFIL↑.FOURBYTES;
END;
FOR I:=INTMAX(LC+1,BC) TO EC DO
GET(FONTFIL);
FOR I:=INTMAX(EC+1,FC) TO LC DO
FONTINFO[FYL,I-FC]:=FBT.FOURBYTES
;

P:=FMEMPTR;
FOR I:=P TO P+M-1 DO
BEGIN GET(FONTFIL);
FMEM[I]:=FONTFIL↑;
END;
FMEMPTR:=FMEMPTR+M;
WDBASE[FYL]:=P;
HTBASE[FYL]:=WDBASE[FYL]+NW;
DPBASE[FYL]:=HTBASE[FYL]+NH;
ICBASE[FYL]:=DPBASE[FYL]+ND;
LGBASE[FYL]:=ICBASE[FYL]+NI;
KRBASE[FYL]:=LGBASE[FYL]+NL;
EXTBASE[FYL]:=KRBASE[FYL]+NK;
PARBASE[FYL]:=EXTBASE[FYL]+NE;
FOR I:=0 TO NW-1 DO
FMEM[WDBASE[FYL]+I].PTS:=
((FMEM[WDBASE[FYL]+I].INT DIV 20B)/4000000B)*METRICSCALE;
FOR I:=0 TO NH-1 DO
FMEM[HTBASE[FYL]+I].PTS:=
((FMEM[HTBASE[FYL]+I].INT DIV 20B)/4000000B)*METRICSCALE;
FOR I:=0 TO ND-1 DO
FMEM[DPBASE[FYL]+I].PTS:=
((FMEM[DPBASE[FYL]+I].INT DIV 20B)/4000000B)*METRICSCALE;
FOR I:=0 TO NI-1 DO
FMEM[ICBASE[FYL]+I].PTS:=
((FMEM[ICBASE[FYL]+I].INT DIV 20B)/4000000B)*METRICSCALE;
FOR I:=0 TO NK-1 DO
FMEM[KRBASE[FYL]+I].PTS:=
((FMEM[KRBASE[FYL]+I].INT DIV 20B)/4000000B)*METRICSCALE;
FMEM[PARBASE[FYL]].PTS:=
((FMEM[PARBASE[FYL]].INT DIV 20B)/4000000B);
FOR I:=1 TO NP-1 DO
FMEM[PARBASE[FYL]+I].PTS:=
((FMEM[PARBASE[FYL]+I].INT DIV 20B)/4000000B)*METRICSCALE;
IF((128<256) AND(EC>LC) AND (FBT.INT>=0)) THEN
READFONTINFO:=2
ELSE READFONTINFO:=0;
END;
END;
PROCEDURE DVI(BYTE:INTEGER);
BEGIN
WITH DVIWORD.FOURBYTES DO
CASE BYTENUM OF
1: BYTE0:=BYTE;
2: BYTE1:=BYTE;
3: BYTE2:=BYTE;
4: BYTE3:=BYTE
END;
BYTENUM:=BYTENUM+1;

IF BYTENUM>4 THEN
BEGIN
OUTFIL↑:=DVIWORD.INT;
PUT(OUTFIL);
BYTENUM:=1;
DVIWORD.INT:=0
END
END;
PROCEDURE INTOUT(I:INTEGER);
VAR HIGHBYTE: INTEGER;
BEGIN
IF I<0 THEN I:=I+FOURBYTEMASK;
HIGHBYTE:=I DIV 16777216;
DVI((HIGHBYTE+256) MOD 256);
I:=I+(-HIGHBYTE)*16777216;
DVI((I DIV 65536) MOD 256);
DVI((I DIV 256) MOD 256);
DVI(I MOD 256);
END;
PROCEDURE CLOSEOUT(DVIBYTECNT,
LASTPAGEPTR, MAGNIFICATION: INTEGER;
MAXPAGEHEIGHT, MAXPAGEWIDTH: REAL;
VAR PARBASE, FCKSUM, FMAG,FONTUSED:
FBASEARRAY);
LABEL 10;
VAR POSTAMBLEPTR,F,I: INTEGER;
J: ASCIICODE;
BEGIN
POSTAMBLEPTR:=DVIBYTECNT;
DVI(131);
INTOUT(LASTPAGEPTR);
INTOUT(1);
INTOUT(1);
INTOUT(MAGNIFICATION);
INTOUT(TRUNC((MAXPAGEHEIGHT)*3514.598
));
INTOUT(TRUNC((MAXPAGEWIDTH)*3514.598
));
FOR F:=0 TO 63 DO
IF FONTUSED[F]<>0 THEN
BEGIN
INTOUT(F);
INTOUT(FCKSUM[F]);
INTOUT(FMAG[F]);
I:=0;
J:=FILENAME[F,I];
WHILE J<>32 DO
BEGIN I:=I+1;
J:=FILENAME[F,I]
END;
DVI(I);
FOR J:=0 TO I-1 DO DVI(FILENAME[F,J]);
END;
INTOUT(-1);
INTOUT(POSTAMBLEPTR);
DVI(1);
FOR I:=1 TO 10 DO DVI(223);
RESET(OUTFIL);
RESET(ERRFIL);
END;
PROCEDURE SETTABLESIZES;
BEGIN
REWRITE(TBLFIL,'PTEXINTBL',0,244570637163B+400000000000B
);
TBLFIL↑:=25012;
PUT(TBLFIL);
TBLFIL↑:=49152;
PUT(TBLFIL);
TBLFIL↑:=1009;
PUT(TBLFIL);
TBLFIL↑:=89;
PUT(TBLFIL);
TBLFIL↑:=1429;
PUT(TBLFIL);
TBLFIL↑:=373;
PUT(TBLFIL);
TBLFIL↑:=116;
PUT(TBLFIL);
TBLFIL↑:=109;
PUT(TBLFIL);
TBLFIL↑:=30;
PUT(TBLFIL);
TBLFIL↑:=8;
PUT(TBLFIL);
TBLFIL↑:=6400;
PUT(TBLFIL);
TBLFIL↑:=23;
PUT(TBLFIL);
END;
PROCEDURE WRITESECONDMEM(VAR MEM:
MEMARRAY);
VAR J: INTEGER;
BEGIN
FOR J:=25012 TO 49152 DO
BEGIN TBLFIL↑:=MEM[J].INT;
PUT(TBLFIL)
END
END;
PROCEDURE WRITEEQTB(VAR EQTB:
EQTBARRAY;
VAR HASH: HASHARRAY;
VAR HHEAD: HHEADARRAY;
VAR HASHPAR: INTEGER;
VAR HASHSEND: INTEGER);
VAR J: INTEGER;
MWORD: MEMORYWORD;
BEGIN
FOR J:=23 TO 1009 DO
BEGIN MWORD.TWOHALVES:=HASH[J];
TBLFIL↑:=MWORD.INT;
PUT(TBLFIL)
END;
FOR J:=0 TO 88 DO
BEGIN TBLFIL↑:=HHEAD[J];
PUT(TBLFIL)
END;
FOR J:=0 TO 1428 DO
BEGIN TBLFIL↑:=EQTB[J].INT;
PUT(TBLFIL)
END;
TBLFIL↑:=HASHPAR;
PUT(TBLFIL);
TBLFIL↑:=HASHSEND;
PUT(TBLFIL)
END;
PROCEDURE WRITEHYPHENTB(VAR READOUTVARIABLE:
TABLEREADOUTTYPE;
VAR EXCEPTABLE: EXCPARRAY;
VAR EXCEPHYPH: EXCPHYARRAY;
VAR SUFFIX: SUFFIXARRAY;
VAR PREFIX: PREFIXARRAY;
VAR BTABLE: BARRAY);
VAR J,K: INTEGER;
BEGIN
WITH READOUTVARIABLE DO
BEGIN
FOR J:=0 TO 372 DO
BEGIN
EXCPTABLEVARIANT:=EXCEPTABLE[J];
FOR K:=1 TO 2 DO
BEGIN TBLFIL↑:=READOUTVARIANT[K];
PUT(TBLFIL)
END;
END;
FOR J:=1 TO 372 DO
BEGIN
EXCEPHYPHVARIANT:=EXCEPHYPH[J];
FOR K:=1 TO 2 DO
BEGIN TBLFIL↑:=READOUTVARIANT[K];
PUT(TBLFIL)
END;
END;
FOR J:=0 TO 115 DO
BEGIN
SUFFIXVARIANT:=SUFFIX[J];
FOR K:=1 TO 3 DO
BEGIN TBLFIL↑:=READOUTVARIANT[K];
PUT(TBLFIL)
END;
END;
FOR J:=0 TO 108 DO
BEGIN
PREFIXVARIANT:=PREFIX[J];
FOR K:=1 TO 3 DO
BEGIN TBLFIL↑:=READOUTVARIANT[K];
PUT(TBLFIL)
END;
END;
FOR J:=2 TO 31 DO
BEGIN
BTABLEVARIANT:=BTABLE[J];
FOR K:=1 TO 3 DO
BEGIN TBLFIL↑:=READOUTVARIANT[K];
PUT(TBLFIL)
END;
END;
END;
END;
PROCEDURE WRITEPAGETB(VAR PAGEMEM:
PAGEMEMARRAY);
VAR MWORD: MEMORYWORD;
J: INTEGER;
BEGIN
FOR J:=0 TO 7 DO
BEGIN MWORD.PTS:=PAGEMEM[J];
TBLFIL↑:=MWORD.INT;
PUT(TBLFIL)
END;
END;
PROCEDURE WRITEDELIMTB(VAR DELIMTABLE:
DELIMARRAY);
VAR J: INTEGER;
DELIM: MEMORYWORD;
BEGIN
FOR J:=0 TO 127 DO
BEGIN DELIM.FOURBYTES:=DELIMTABLE[J];
TBLFIL↑:=DELIM.INT;
PUT(TBLFIL)
END;
END;
PROCEDURE WRITEFMEM(VAR FMEM:
FMEMARRAY;
VAR WDBASE,HTBASE,DPBASE,ICBASE,LGBASE,KRBASE,EXTBASE,PARBASE:
FBASEARRAY;
VAR FONTINFO: FNTINFOARRAY;
VAR FCKSUM,FPFB,FMAG: FBASEARRAY;
VAR FPFI: FPFIARRAY;
VAR FMEMPTR: INTEGER);
VAR MWORD: MEMORYWORD;
J,K: INTEGER;
BEGIN
FOR J:=0 TO 6399 DO
BEGIN TBLFIL↑:=FMEM[J].INT;
PUT(TBLFIL)
END;
FOR J:=0 TO 63 DO
BEGIN TBLFIL↑:=WDBASE[J];
PUT(TBLFIL);
END;
FOR J:=0 TO 63 DO
BEGIN TBLFIL↑:=HTBASE[J];
PUT(TBLFIL);
END;
FOR J:=0 TO 63 DO
BEGIN TBLFIL↑:=DPBASE[J];
PUT(TBLFIL);
END;
FOR J:=0 TO 63 DO
BEGIN TBLFIL↑:=ICBASE[J];
PUT(TBLFIL);
END;
FOR J:=0 TO 63 DO
BEGIN TBLFIL↑:=LGBASE[J];
PUT(TBLFIL);
END;
FOR J:=0 TO 63 DO
BEGIN TBLFIL↑:=KRBASE[J];
PUT(TBLFIL);
END;
FOR J:=0 TO 63 DO
BEGIN TBLFIL↑:=EXTBASE[J];
PUT(TBLFIL);
END;
FOR J:=0 TO 63 DO
BEGIN TBLFIL↑:=PARBASE[J];
PUT(TBLFIL);
END;
FOR J:=0 TO 63 DO
FOR K:=0 TO 127 DO
BEGIN MWORD.FOURBYTES:=FONTINFO[J,K];
TBLFIL↑:=MWORD.INT;
PUT(TBLFIL);
END;
FOR J:=0 TO 63 DO
BEGIN TBLFIL↑:=FCKSUM[J];
PUT(TBLFIL);
END;
FOR J:=0 TO 63 DO
BEGIN TBLFIL↑:=FPFB[J];
PUT(TBLFIL);
END;
FOR J:=0 TO 63 DO
BEGIN TBLFIL↑:=FMAG[J];
PUT(TBLFIL);
END;
FOR J:=0 TO 63 DO
FOR K:=1 TO 5 DO
BEGIN MWORD.FOURBYTES:=FPFI[J,K];
TBLFIL↑:=MWORD.INT;
PUT(TBLFIL);
END;
TBLFIL↑:=FMEMPTR;
PUT(TBLFIL)
END;
FUNCTION GETTABLESIZES(VAR SIZESTABLE:
SIZESARRAY):BOOLEAN;
VAR J: INTEGER;
BEGIN
RESET(TBLFIL,'PTEXINTBL',0,244570637163B+400000000000B
);
FOR J:=0 TO 11 DO
BEGIN SIZESTABLE[J]:=TBLFIL↑;
GET(TBLFIL)
END;
GETTABLESIZES:=NOT EOF(TBLFIL)

END;
PROCEDURE INITSECONDMEM(VAR MEM:
MEMARRAY);
VAR J: INTEGER;
BEGIN
FOR J:=25012 TO 49152 DO
BEGIN MEM[J].INT:=TBLFIL↑;
GET(TBLFIL)
END
END;
PROCEDURE INITEQTB(VAR EQTB: EQTBARRAY;
VAR HASH: HASHARRAY;
VAR HHEAD: HHEADARRAY;
VAR HASHPAR: INTEGER;
VAR HASHSEND: INTEGER);
VAR J: INTEGER;
MWORD: MEMORYWORD;
BEGIN
FOR J:=23 TO 1009 DO
BEGIN MWORD.INT:=TBLFIL↑;
HASH[J]:=MWORD.TWOHALVES;
GET(TBLFIL)
END;
FOR J:=0 TO 88 DO
BEGIN HHEAD[J]:=TBLFIL↑;
GET(TBLFIL)
END;
FOR J:=0 TO 1428 DO
BEGIN EQTB[J].INT:=TBLFIL↑;
GET(TBLFIL)
END;
HASHPAR:=TBLFIL↑;
GET(TBLFIL);
HASHSEND:=TBLFIL↑;
GET(TBLFIL);
END;
PROCEDURE INITPAGETB(VAR PAGEMEM:
PAGEMEMARRAY);
VAR MWORD: MEMORYWORD;
J: INTEGER;
BEGIN
FOR J:=0 TO 7 DO
BEGIN MWORD.INT:=TBLFIL↑;
PAGEMEM[J]:=MWORD.PTS;
GET(TBLFIL)
END;
END;
PROCEDURE INITDELIMTB(VAR DELIMTABLE:
DELIMARRAY);
VAR J: INTEGER;
DELIM: MEMORYWORD;
BEGIN
FOR J:=0 TO 127 DO
BEGIN DELIM.INT:=TBLFIL↑;
DELIMTABLE[J]:=DELIM.FOURBYTES;
GET(TBLFIL)
END;
END;
PROCEDURE INITFMEM(VAR FMEM: FMEMARRAY;
VAR WDBASE,HTBASE,DPBASE,ICBASE,LGBASE,KRBASE,EXTBASE,PARBASE:
FBASEARRAY;
VAR FONTINFO: FNTINFOARRAY;
VAR FCKSUM,FPFB,FMAG: FBASEARRAY;
VAR FPFI: FPFIARRAY;
VAR FMEMPTR: INTEGER);
VAR MWORD: MEMORYWORD;
J,K: INTEGER;
BEGIN
FOR J:=0 TO 6399 DO
BEGIN FMEM[J].INT:=TBLFIL↑;
GET(TBLFIL)
END;
FOR J:=0 TO 63 DO
BEGIN WDBASE[J]:=TBLFIL↑;
GET(TBLFIL);
END;
FOR J:=0 TO 63 DO
BEGIN HTBASE[J]:=TBLFIL↑;
GET(TBLFIL);
END;
FOR J:=0 TO 63 DO
BEGIN DPBASE[J]:=TBLFIL↑;
GET(TBLFIL);
END;
FOR J:=0 TO 63 DO
BEGIN ICBASE[J]:=TBLFIL↑;
GET(TBLFIL);
END;
FOR J:=0 TO 63 DO
BEGIN LGBASE[J]:=TBLFIL↑;
GET(TBLFIL);
END;
FOR J:=0 TO 63 DO
BEGIN KRBASE[J]:=TBLFIL↑;
GET(TBLFIL);
END;
FOR J:=0 TO 63 DO
BEGIN EXTBASE[J]:=TBLFIL↑;
GET(TBLFIL);
END;
FOR J:=0 TO 63 DO
BEGIN PARBASE[J]:=TBLFIL↑;
GET(TBLFIL);
END;
FOR J:=0 TO 63 DO
FOR K:=0 TO 127 DO
BEGIN MWORD.INT:=TBLFIL↑;
FONTINFO[J,K]:=MWORD.FOURBYTES;
GET(TBLFIL);
END;
FOR J:=0 TO 63 DO
BEGIN FCKSUM[J]:=TBLFIL↑;
GET(TBLFIL);
END;
FOR J:=0 TO 63 DO
BEGIN FPFB[J]:=TBLFIL↑;
GET(TBLFIL);
END;
FOR J:=0 TO 63 DO
BEGIN FMAG[J]:=TBLFIL↑;
GET(TBLFIL);
END;
FOR J:=0 TO 63 DO
FOR K:=1 TO 5 DO
BEGIN MWORD.INT:=TBLFIL↑;
FPFI[J,K]:=MWORD.FOURBYTES;
GET(TBLFIL);
END;
FMEMPTR:=TBLFIL↑;
GET(TBLFIL);
END;
PROCEDURE INITHYPHENTB(VAR READOUTVARIABLE:
TABLEREADOUTTYPE;
VAR EXCEPTABLE: EXCPARRAY;
VAR EXCEPHYPH: EXCPHYARRAY;
VAR SUFFIX: SUFFIXARRAY;
VAR PREFIX: PREFIXARRAY;
VAR BTABLE: BARRAY);
VAR J,K: INTEGER;
BEGIN
WITH READOUTVARIABLE DO
BEGIN
FOR J:=0 TO 372 DO
BEGIN
FOR K:=1 TO 2 DO
BEGIN READOUTVARIANT[K]:=TBLFIL↑;
GET(TBLFIL)
END;
EXCEPTABLE[J]:=EXCPTABLEVARIANT

END;
FOR J:=1 TO 372 DO
BEGIN
FOR K:=1 TO 2 DO
BEGIN READOUTVARIANT[K]:=TBLFIL↑;
GET(TBLFIL)
END;
EXCEPHYPH[J]:=EXCEPHYPHVARIANT

END;
FOR J:=0 TO 115 DO
BEGIN
FOR K:=1 TO 3 DO
BEGIN READOUTVARIANT[K]:=TBLFIL↑;
GET(TBLFIL)
END;
SUFFIX[J]:=SUFFIXVARIANT
END;
FOR J:=0 TO 108 DO
BEGIN
FOR K:=1 TO 3 DO
BEGIN READOUTVARIANT[K]:=TBLFIL↑;
GET(TBLFIL)
END;
PREFIX[J]:=PREFIXVARIANT
END;
FOR J:=2 TO 31 DO
BEGIN
FOR K:=1 TO 3 DO
BEGIN READOUTVARIANT[K]:=TBLFIL↑;
GET(TBLFIL)
END;
BTABLE[J]:=BTABLEVARIANT
END;
END;
END;
BEGIN
END.